RAPID AND AGILE STABILITY Architecting for Sustainable Software Delivery

With increasing emphasis on avionics system rapid development and reduced cycle times, software architecting practices can be applied with agility to enhance evolving stakeholder concerns while sustaining long-term business goals. The Networked Common Operating Real-Time Environment (NCORE) software architecture for the Apache Longbow helicopter Mission Processor provides a case study to illustrate the architecting practices that support agility and sustainment of long-term business goals. The NCORE architecture was initially developed and flight-tested during the jointly funded Army Aviation Technology Directorate (AATD) and Boeing Manned/Unmanned Common Architecture Program, Phase II (MCAP II). The MCAP II risk reduction program initially focused on the evaluation of emerging software technologies such as real-time Java. Since then, the NCORE architecture continues to evolve on the Apache Longbow Block III Program. The driving architectural requirements include safety, performance, availability/reliability, modifiability, and interoperability. As initial platform capabilities are realized and as avionics computing lifecycles shorten, increased emphasis is placed on extensibility and the desire to host applications developed by third parties. In parallel, embedded infrastructure software must be architected to reduce overall time and cost to incorporate hardware upgrades (proactive obsolescence management) and to enable the hosting of new or existing application-level software. In the section that follows, each practice is described and illustrated with an NCORE architecture example. Next, incremental delivery of new capabilities is described in terms of how it is realized by combining all of the practices. Finally, the essential characteristics of the practices are summarized according to agile development and architecture criteria. This summary provides a checklist to aid learning for others developing software-reliant systems, and provides feedback on whether their application is on track to help meet project goals. Architecture Practices That Balance Flexibility and Stability Architecture best practices are a set of actions, methods, techniques, and/or strategies applied to software architecting and the software lifecycle that are well proven and known to yield desired outcomes without introducing unnecessary program risk. Those architecting practices that are leveraged by the NCORE architecture and that can be broadly applied to avionics platforms are now described and analyzed from the point of view of agility. Incremental/Iterative Development NCORE architecture and application software artifacts are developed using an incremental and iterative development lifecycle [3], notionally shown on a fiscal year calendar in Figure 1. Based on periodic customer statements of work, incremental capabilities are planned, developed, tested, and fielded. For each statement of work iteration, integrated build and release plans are developed. To enhance testability and integrability, software builds contain two or more mini-builds that accelerate design, development, automated testing, and platform integration. This incremental/iterative development approach parallels agile software development, with cross-functional/agile teams of requirements/integrators, coders, and testers working according to agreed-upon release planning (the build plan). Incremental/iterative Software intensive systems, and in particular military avionics platforms, are facing both shrinking defense budgets and the continued expectation for more advanced mission capabilities. The business case is that it is much more affordable to extend existing platform capabilities than to consider new platform designs. Over a product lifecycle, business goals and objectives continue to evolve as capabilities are realized. Paramount to enhancing current platform capabilities is an extensible and sound avionics system and mission-computing software architecture. This article describes the role that five architecture practices are continuing to play in enabling the Apache Block III program to achieve long-term business goals. Agility is applied according to Jim Highsmith’s definition, which describes it in terms of balancing flexibility and stability [1]. Such agility enables architectural development to follow a “just-in-time” model that complements iterative and incremental enhancement development and integration [2]. Delivery of capabilities is not delayed pending the completion of exhaustive requirements and design activities and reviews. At the same time, architectural agility maintains a steady and consistent focus on continual architectural evolution in support of emerging capabilities.